home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Magnum One
/
Magnum One (Mid-American Digital) (Disc Manufacturing).iso
/
d18
/
kruse_11.arc
/
ADDHASH.PAS
< prev
next >
Wrap
Pascal/Delphi Source File
|
1990-11-30
|
3KB
|
109 lines
program MergeHashFiles(HashFile, NewHashFile, input, output);
const
maxwd = 20;
hashsize = 2003;
blank = ' ';
type
word = packed array[1..maxwd] of char;
reference = record
wd: word;
pg: integer
end;
hashentry = 1..hashsize;
var
HashFile,
NewHashFile: text;
blankword: word;
i: integer;
procedure UpdateHashFile;
{reads in old hash table, inserts file of new entries; writes out to HashFile}
{Updated version, uses hash tables of reference (not word) and hash files of
type text (not word).}
var
hash: array[hashentry] of reference;
x: hashentry;
NewFile,
w: word;
function HashAddress(w: word): hashentry;
{calculates the location in hash table of word w, or, if not there,
returns pointing to the blank word where w should go}
var
x, {calculated location}
inc: integer; {increment for open addressing}
begin {function HashAddress}
x := abs(ord(w[1])*ord(w[2])+ord(w[4])+ord(w[6])) mod hashsize + 1;
{Hash function assumes long word length. For short word machines
we must ensure that the result is non-negative, and worry about overflow.}
if (hash[x].wd <> w) and (hash[x].wd <> blankword) then
begin
inc := (abs(ord(w[3])-95) mod 29);
{A key dependent increment is used to avoid clustering.}
repeat
inc := inc + 1;
if inc > hashsize then
writeln(w,' causes hash table to become full, infinite loop.');
x := x + inc;
if x > hashsize then x := x - hashsize;
until (w = hash[x].wd) or (blankword = hash[x].wd)
end;
HashAddress := x
end; {function HashAddress}
begin {procedure UpdateHashFile}
reset(HashFile);
if eof(HashFile) then {Error handler}
for x := 1 to hashsize do {HashFile is empty; create new table.}
begin
hash[x].wd := blankword;
hash[x].pg := 0
end
else
for x := 1 to hashsize do
begin
read(HashFile, hash[x].pg);
while (HashFile^ = ' ') and not eoln(HashFile) do
get(HashFile);
readln(HashFile, hash[x].wd)
end;
reset(NewHashFile);
while not eof(NewHashFile) do
begin
readln(NewHashFile, w);
hash[HashAddress(w)].wd := w
{An identical hash function as used in phase 1 will be used.
Overflow is a possibility.}
end;
close(HashFile);
{ In some system it may be necessary to close file HashFile at this point.}
write('File name for updated hashfile?');
readln(NewFile);
open(HashFile, NewFile, new);
rewrite(HashFile);
for x := 1 to hashsize do
with hash[x] do
begin
write(HashFile, pg:4, ' ');
if wd <> blankword then
write(HashFile, wd);
writeln(HashFile)
end
end; {procedure UpdateHashFile}
begin {main program MergeHashFiles}
for i := 1 to maxwd do
blankword[i] := blank;
UpdateHashFile;
end. {main program MergeHashFiles}